## 6.2. Managing Swap Space

Swap space is a generic term for disk storage used to increase the amount of apparent memory available on the system. Under Linux, swap space is used to implement paging, a process whereby memory pages (a page is 4096 bytes on Intel systems; this value can differ on other architectures) are written out to disk when physical memory is low and read back into physical memory when needed. The process by which paging works is rather involved, but it is optimized for certain cases. The virtual memory subsystem under Linux allows memory pages to be shared between running programs. For example, if you have multiple copies of Emacs running simultaneously, there is only one copy of the Emacs code actually in memory. Also, text pages (those pages containing program code, not data) are usually read-only, and therefore not written to disk when swapped out. Those pages are instead freed directly from main memory and read from the original executable file when they are accessed again.

Of course, swap space cannot completely make up for a lack of physical RAM. Disk access is much slower than RAM access, by several orders of magnitude. Therefore, swap is useful primarily as a means to run a number of programs simultaneously that would not otherwise fit into physical RAM; if you are switching between these programs rapidly you'll notice a lag as pages are swapped to and from disk.

At any rate, Linux supports swap space in two forms: as a separate disk partition or a file somewhere on your existing Linux filesystems. You can have up to 16 swap areas, with each swap area being a disk file or partition up to 128 MB in size (again, these values can differ on non-Intel systems). You math whizzes out there will realize that this allows up to 2 GB of swap space. (If anyone has actually attempted to use this much swap, the authors would love to hear about it, whether you're a math whiz or not.)

Note that using a swap partition can yield better performance, because the disk blocks are guaranteed to be contiguous. In the case of a swap file, however, the disk blocks may be scattered around the filesystem, which can be a serious performance hit in some cases. Many people use a swap file when they must add additional swap space temporarily--for example, if the system is thrashing because of lack of physical RAM and swap. Swap files are a good way to add swap on demand.

Nearly all Linux systems utilize swap space of some kind--usually a single swap partition. In Chapter 3, "Installation and Initial Configuration", we explained how to create a swap partition on your system during the Linux installation procedure. In this section we describe how to add and remove swap files and partitions. If you already have swap space and are happy with it, this section may not be of interest to you.

How much swap space do you have? The `free` command reports information on system-memory usage:

>     rutabaga% free
>                 total       used       free     shared    buffers     cached
>     Mem:        127888     126744       1144      27640       1884      51988
>     -/+ buffers:            72872      55016
>     Swap:       130748      23916     106832

All the numbers here are reported in 1024-byte blocks. Here, we see a system with 127,888 blocks (about 127 MB) of physical RAM, with 126,744 (about 126 MB) currently in use. Note that your system actually has more physical RAM than that given in the "total" column; this number does not include the memory used by the kernel for its own sundry needs.

The "shared" column lists the amount of physical memory shared between multiple processes. Here, we see that about 27 MB of pages are being shared, which means that memory is being utilized well. The "buffers" column shows the amount of memory being used by the kernel buffer cache. The buffer cache (described briefly in the previous section) is used to speed up disk operations, by allowing disk reads and writes to be serviced directly from memory. The buffer cache size will increase or decrease as memory usage on the system changes; this memory is reclaimed if it is needed by applications. Therefore, although we see that 126 MB of system memory is in use, not all (but most) of it is being used by application programs. The "cache" column indicates how many memory pages the kernel has cached for faster access later.

Since the memory used for buffers and cache can easily be reclaimed for use by applications, the second line (-/+ buffers/cache) provides an indication of the memory actually used by applications (the "used" column) or available to applications (the "free" column). The sum of the memory used by buffers and cache reported in the first line is subtracted from the total used memory and added to the total free memory to give the two figures on the second line.

In the third line, we see the total amount of swap, 130,748 blocks (about 128 MB). In this case, only very little of the swap is being used; there is plenty of physical RAM available. If additional applications were started, larger parts of the buffer cache memory would be used to host them. Swap space is generally used as a last resort when the system can't reclaim physical memory in other ways.

Note that the amount of swap reported by `free` is somewhat less than the total size of your swap partitions and files. This is because several blocks of each swap area must be used to store a map of how each page in the swap area is being utilized. This overhead should be rather small; only a few kilobytes per swap area.

If you're considering creating a swap file, the `df` command gives you information on the amount of space remaining on your various filesystems. This command prints a list of filesystems, showing each one's size and what percentage is currently occupied.

### 6.2.1. Creating Swap Space

The first step in adding additional swap is to create a file or partition to host the swap area. If you wish to create an additional swap partition, you can create the partition using the `fdisk` utility, as described in the section "Section 3.1.3, "Creating Linux Partitions"" in Chapter 3, "Installation and Initial Configuration".

To create a swap file, you'll need to open a file and write bytes to it equaling the amount of swap you wish to add. One easy way to do this is with the `dd` command. For example, to create an 8-MB swap file, you can use the command:

>     dd if=/dev/zero of=/swap bs=1024 count=8192

This will write 8192 blocks (8 MB) of data from /dev/zero to the file /swap. (/dev/zero is a special device in which read operations always return null bytes. It's something like the inverse of /dev/null.) After creating a file of this size, it's a good idea to use the `sync` command to sync the filesystems in case of a system crash.

Once you have created the swap file or partition, you can use the `mkswap` command to "format" the swap area. As described in the section "Section 3.1.4, "Creating Swap Space"" in Chapter 3, "Installation and Initial Configuration", the format of the `mkswap` command is:

>     mkswap -c device size

where device is the name of the swap partition or file, and size is the size of the swap area in blocks (again, one block is equal to one kilobyte). You normally do not need to specify this when creating a swap area, because `mkswap` can detect the partition size on its own. The -c switch is optional and causes the swap area to be checked for bad blocks as it is formatted.

For example, for the swap file created in the previous example, you would use the command:

>     mkswap -c /swap 8192

If the swap area is a partition, you would substitute the name of the partition (such as /dev/hda3) and the size of the partition, also in blocks.

After running `mkswap` on a swap file, use the `sync` command to ensure the format information has been physically written to the new swap file. Running `sync` is not necessary when formatting a swap partition.

### 6.2.2. Enabling the Swap Space

In order for the new swap space to be utilized, you must enable it with the `swapon` command. For example, after creating the previous swap file and running `mkswap` and `sync`, we could use the command:

>     swapon /swap

This adds the new swap area to the total amount of available swap; use the `free` command to verify that this is indeed the case. If you are using a new swap partition, you can enable it with a command such as:

>     swapon /dev/hda3

if /dev/hda3 is the name of the swap partition.

If you are using a swap file (and not a swap partition), you need to change its permissions first, like:

>     chmod 0600 /swap

Like filesystems, swap areas are automatically enabled at boot time using the `swapon -a` command from one of the system startup files (usually in /etc/rc.d/rc.sysinit). This command looks in the file /etc/fstab, which, as you'll remember from the section "Section 6.1.2, "Mounting Filesystems"," includes information on filesystems and swap areas. All entries in /etc/fstab with the options field set to `sw` are enabled by `swapon -a`.

Therefore, if /etc/fstab contains the entries:

>     # device     directory    type   options
>     /dev/hda3    none         swap   sw
>     /swap        none         swap   sw

then the two swap areas /dev/hda3 and /swap will be enabled at boot time. For each new swap area, you should add an entry to /etc/fstab.

### 6.2.3. Disabling Swap Space

As is usually the case, undoing a task is easier than doing it. To disable swap space, simply use the command:

>     swapoff device

where device is the name of the swap partition or file that you wish to disable. For example, to disable swapping on the device /dev/hda3, use the command:

>     swapoff /dev/hda3

If you wish to disable a swap file, you can simply remove the file, using `rm`, after using `swapoff`. Don't remove a swap file before disabling it; this can cause disaster.

If you have disabled a swap partition using `swapoff`, you are free to reuse that partition as you see fit: remove it using `fdisk`, or do whatever.

Also, if there is a corresponding entry for the swap area in /etc/fstab, remove it. Otherwise, you'll get errors when you next reboot the system and the swap area can't be found.

Copyright © 2001 O'Reilly & Associates. All rights reserved.